home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 April: Mac OS SDK / Dev.CD Apr 96 SDK / Dev.CD Apr 96 SDK1.toast / Development Kits (Disc 1) / OpenDoc / Sample Code / CALib & You… / Source / CASample / CAS_ToolPalette.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-07  |  7.9 KB  |  403 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        CAS_Win.c
  3.  
  4.     Contains:    window-handling routines.
  5.  
  6.     Written by:    David H Nelson
  7.  
  8.     Copyright © 1995 ComponentWorks, All rights reserved.
  9.  
  10.     Change History (most recent first):
  11.         01/14/95    DAS     created this file
  12. */
  13.  
  14. #include "CAS_ToolPalette.h"
  15.  
  16. #include "CAS_App.h"
  17. #include "CAS_Win.h"
  18. #include "CAS_StringTools.h"
  19. #include "CAS_Menu.h"
  20.  
  21.  
  22. WindowPtr    gToolPaletteW = nil;
  23. short        gSelectedCell = (-1);
  24. Boolean        gToolPaletteInitialized = false;
  25. PicHandle        *gCellPicts = nil;
  26. short        gCellPictsCount = 0;
  27.  
  28.  
  29. WindowPtr ToolPalette_Create(
  30.     PicHandle    *picsReference,
  31.     short    itemCount,
  32.     short    currentItem )
  33. {
  34. WindowPtr    targetWindow;
  35. GrafPtr        savedPort;
  36.  
  37.     GetPort( &savedPort );
  38.  
  39.     targetWindow = GetNewCWindow( WIND_ToolPalette, nil, (WindowPtr)(-1) );
  40.     if (targetWindow != nil)
  41.     {
  42.         /* wedge the windowKind field so that the window can be identified as a floating window */
  43.         Win_SetFloaterKind( targetWindow );
  44.  
  45.         if (gToolPaletteW == nil)
  46.             gToolPaletteW = targetWindow;
  47.  
  48.         Win_ShowHide( targetWindow, true );
  49.         gCellPicts = picsReference;
  50.         gCellPictsCount = itemCount;
  51.         gSelectedCell = currentItem;
  52.         if (gSelectedCell >= gCellPictsCount)
  53.             gSelectedCell = 0;
  54.     }
  55.  
  56.     SetPort( savedPort );
  57.  
  58.     return targetWindow;
  59. }
  60.  
  61.  
  62. void ToolPalette_Dispose(
  63.     WindowPtr    targetWindow )
  64. {
  65.     targetWindow = ToolPalette_VerifyWindow( targetWindow );
  66.     if (targetWindow != nil)
  67.     {
  68.         DisposeWindow( targetWindow );
  69.         targetWindow = nil;
  70.     }
  71.  
  72.     if (gToolPaletteW == targetWindow)
  73.         gToolPaletteW = nil;
  74.     gCellPicts = nil;
  75.     gCellPictsCount = 0;
  76.     gSelectedCell = (-1);
  77. }
  78.  
  79.  
  80. WindowPtr ToolPalette_GetWindow( void )
  81. {
  82.     return gToolPaletteW;
  83. }
  84.  
  85. void ToolPalette_Render(
  86.     WindowPtr    targetWindow )
  87. {
  88. Rect        cellR;
  89. GrafPtr    savedPort;
  90. short    selectedCell, i;
  91.  
  92.     targetWindow = ToolPalette_VerifyWindow( targetWindow );
  93.     if (targetWindow == nil)
  94.         return;
  95.  
  96.     GetPort( &savedPort );
  97.     SetPort( (GrafPtr)targetWindow );
  98.  
  99.     selectedCell = ToolPalette_GetSelectedCell( targetWindow );
  100.     if (gCellPicts != nil)
  101.         for (i=0; i<ToolPalette_CellCount; i++)
  102.             if (gCellPicts[i] != nil)
  103.             {
  104.                 ToolPalette_GetCellRect( targetWindow, i, &cellR );
  105.                 InsetRect( &cellR, 2, 2 );
  106.                 DrawPicture( gCellPicts[i], &cellR );
  107.  
  108.                 if (i == selectedCell)
  109.                     ToolPalette_HighlightCell( targetWindow, i );
  110.             }
  111.  
  112.     SetPort( savedPort );
  113. }
  114.  
  115.  
  116. Boolean ToolPalette_IsEvent(
  117.     WindowPtr    targetWindow,
  118.     EventRecord    *targetEvent )
  119. {
  120. WindowPtr    eventWindow;
  121. short        pressedWindowPart;
  122. Boolean        ownsEvent;
  123. char            theChar;
  124.  
  125.     targetWindow = ToolPalette_VerifyWindow( targetWindow );
  126.     if ((targetEvent == nil) || !Win_IsVisible( targetWindow ))
  127.         return false;
  128.  
  129.     ownsEvent = false;
  130.     switch (targetEvent->what)
  131.     {
  132.         case mouseDown:
  133.         case mouseUp:
  134.             pressedWindowPart = FindWindow( targetEvent->where, &eventWindow );
  135.             ownsEvent = (eventWindow == targetWindow);
  136.             break;
  137.  
  138.         case activateEvt:
  139.         case updateEvt:
  140.             eventWindow = (WindowPtr)(targetEvent->message);
  141.             ownsEvent = (eventWindow == targetWindow);
  142.             break;
  143.  
  144.         case keyDown:
  145.         case autoKey:
  146.             if (targetWindow != FrontWindow())
  147.                 break;
  148.  
  149.             if (!(targetEvent->modifiers & cmdKey))
  150.                 ownsEvent = true;
  151.             else
  152.             {
  153.                 theChar = (char)(targetEvent->message & charCodeMask);
  154.                 ownsEvent = (MenuKey( theChar ) == 0L);
  155.             }
  156.             break;
  157.  
  158.         case osEvt:    /* app4Evt in System 6 / Think 4.0 */
  159.             ownsEvent = (((targetEvent->message >> 24) & 0x000000FF) == mouseMovedMessage);
  160.             break;
  161.  
  162.         case diskEvt:
  163.         default:
  164.             break;
  165.     }
  166.  
  167.     return ownsEvent;
  168. }
  169.  
  170.  
  171. Boolean ToolPalette_DoEvent(
  172.     WindowPtr    targetWindow,
  173.     EventRecord    *targetEvent )
  174. {
  175. WindowPtr    eventWindow;
  176. GrafPtr        savedPort;
  177. short        theWindowPart, acceptedEvent;
  178. Boolean        makeActive;
  179.  
  180.     targetWindow = ToolPalette_VerifyWindow( targetWindow );
  181.     if ((targetEvent == nil) || !Win_IsVisible( targetWindow ))
  182.         return false;
  183.  
  184.     acceptedEvent = false;
  185.     switch (targetEvent->what)
  186.     {
  187.         case mouseDown:
  188.             theWindowPart = FindWindow( targetEvent->where, &eventWindow );
  189.             ToolPalette_DoMouseDownEvent( eventWindow, targetEvent, theWindowPart );
  190.             acceptedEvent = (theWindowPart != 0);
  191.             break;
  192.  
  193.         case activateEvt:
  194.             makeActive = ((targetEvent->modifiers & activeFlag) != 0);
  195.             if (makeActive)
  196.                 SetPort( (GrafPtr)targetWindow );
  197.             acceptedEvent = true;
  198.             break;
  199.  
  200.         case updateEvt:
  201.             GetPort( &savedPort );
  202.             SetPort( (GrafPtr)targetWindow );
  203.             BeginUpdate( targetWindow );
  204.             ToolPalette_Render( targetWindow );
  205.             EndUpdate( targetWindow );
  206.             SetPort( savedPort );
  207.  
  208.             acceptedEvent = true;
  209.             break;
  210.  
  211.         case keyDown:
  212.         case autoKey:
  213.             acceptedEvent = false;
  214.             break;
  215.  
  216.         default:
  217.             break;
  218.     }
  219.  
  220.     return acceptedEvent;
  221. }
  222.  
  223.  
  224. void ToolPalette_DoMouseDownEvent(
  225.     WindowPtr    targetWindow,
  226.     EventRecord    *targetEvent,
  227.     short        windowPart )
  228. {
  229. Rect        dragBoundsR;
  230. Point        curMouse;
  231. short    curIndex, newIndex, origIndex;
  232. GrafPtr    savedPort;
  233.  
  234.     targetWindow = ToolPalette_VerifyWindow( targetWindow );
  235.     if (targetWindow == nil)
  236.         return;
  237.  
  238.     GetPort( &savedPort );
  239.     SetPort( (GrafPtr)targetWindow );
  240.  
  241.     switch (windowPart)
  242.     {
  243.         case inDrag:
  244.             dragBoundsR = qd.screenBits.bounds;
  245.             Win_DragWindow_Better( targetWindow, targetEvent->where, &dragBoundsR );
  246.             break;
  247.  
  248.         case inContent:
  249.             origIndex = ToolPalette_GetSelectedCell( targetWindow );
  250.             curIndex = origIndex;
  251.             while (WaitMouseUp())
  252.             {
  253.                 GetMouse( &curMouse );
  254.                 newIndex = ToolPalette_PointToCellIndex( targetWindow, curMouse );
  255.                 if (!ToolPalette_ValidCellIndex( newIndex ))
  256.                     newIndex = origIndex;
  257.  
  258.                 if (curIndex != newIndex)
  259.                 {
  260.                     curIndex = newIndex;
  261.                     ToolPalette_SetSelectedCell( targetWindow, curIndex );
  262.                 }
  263.             }
  264.  
  265.             if (curIndex != origIndex)
  266.                 ToolPalette_DoCommand( targetWindow, curIndex );
  267.             break;
  268.  
  269.         default:
  270.             break;
  271.     }
  272.  
  273.     SetPort( savedPort );
  274. }
  275.  
  276.  
  277. void ToolPalette_DoCommand(
  278.     WindowPtr    targetWindow,
  279.     short        cellIndex )
  280. {
  281. WindowPtr    frontDocW;
  282. short        menuCmdSelector;
  283.  
  284.     if (ToolPalette_ValidCellIndex( cellIndex ))
  285.     {
  286.         menuCmdSelector = cellIndex + 1;
  287.         frontDocW = App_GetFrontDocWindow();
  288.         App_HandleToolMenu( menuCmdSelector, frontDocW );
  289.         Menu_AdjustMenus( frontDocW );
  290.     }
  291. }
  292.  
  293.  
  294. short ToolPalette_GetSelectedCell(
  295.     WindowPtr    targetWindow )
  296. {
  297.     return gSelectedCell;
  298. }
  299.  
  300.  
  301. void ToolPalette_SetSelectedCell(
  302.     WindowPtr    targetWindow,
  303.     short        newIndex )
  304. {
  305. GrafPtr    savedPort;
  306.  
  307.     targetWindow = ToolPalette_VerifyWindow( targetWindow );
  308.  
  309.     if (ToolPalette_ValidCellIndex( newIndex ))
  310.         if (gSelectedCell != newIndex)
  311.         {
  312.             if (targetWindow != nil)
  313.             {
  314.                 GetPort( &savedPort );
  315.                 SetPort( (GrafPtr)targetWindow );
  316.  
  317.                 ToolPalette_HighlightCell( targetWindow, gSelectedCell );
  318.                 ToolPalette_HighlightCell( targetWindow, newIndex );
  319.  
  320.                 SetPort( savedPort );
  321.             }
  322.  
  323.             gSelectedCell = newIndex;
  324.         }
  325. }
  326.  
  327.  
  328. void ToolPalette_HighlightCell(
  329.     WindowPtr    targetWindow,
  330.     short        cellIndex )
  331. {
  332. PenState    savedPenState;
  333. Rect        cellR;
  334.  
  335.     targetWindow = ToolPalette_VerifyWindow( targetWindow );
  336.     if ((targetWindow != nil) && ToolPalette_ValidCellIndex( cellIndex ))
  337.     {
  338.         ToolPalette_GetCellRect( targetWindow, cellIndex, &cellR );
  339.  
  340.         GetPenState( &savedPenState );
  341.         PenNormal();
  342.         PenMode( patXor | 50 );
  343.         FrameRect( &cellR );
  344.         SetPenState( &savedPenState );
  345.     }
  346. }
  347.  
  348.  
  349. short ToolPalette_PointToCellIndex(
  350.     WindowPtr    targetWindow,
  351.     Point            location )
  352. {
  353. Rect        cellR;
  354. short    i;
  355.  
  356.     for (i=0; i<ToolPalette_CellCount; i++)
  357.     {
  358.         ToolPalette_GetCellRect( targetWindow, i, &cellR );
  359.         if (PtInRect( location, &cellR ))
  360.             return i;
  361.     }
  362.  
  363.     return -1;
  364. }
  365.  
  366.  
  367. void ToolPalette_GetCellRect(
  368.     WindowPtr    targetWindow,
  369.     short        cellIndex,
  370.     Rect            *boundsR )
  371. {
  372.     if (boundsR == nil)
  373.         return;
  374.  
  375.     targetWindow = ToolPalette_VerifyWindow( targetWindow );
  376.     if ((targetWindow == nil) || !ToolPalette_ValidCellIndex( cellIndex ))
  377.         SetRect( boundsR, 0, 0, 0, 0 );
  378.     else
  379.     {
  380.         SetRect( boundsR, 0, 0, ToolPalette_CellH, ToolPalette_CellV );
  381.         OffsetRect( boundsR, 4 + cellIndex * ToolPalette_CellH, 4 );
  382.     }
  383. }
  384.  
  385.  
  386. WindowPtr ToolPalette_VerifyWindow(
  387.     WindowPtr    targetWindow )
  388. {
  389.     if (targetWindow == nil)
  390.         targetWindow = gToolPaletteW;
  391.  
  392.     return targetWindow;
  393. }
  394.  
  395.  
  396. Boolean ToolPalette_ValidCellIndex(
  397.     short    cellIndex )
  398. {
  399.     return ((cellIndex >= 0) && (cellIndex < ToolPalette_CellCount));
  400. }
  401.  
  402.  
  403.